package com.spark.demo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * @Author sc
 * @DATE 2024/5/28 13:49
 * @Description:
 * @Version 1.0
 */
public class Demo1 {
    public static void main(String[] args) {
        int [] arr = {3,6,9,1,2,6,12,24,89,30};
        System.out.println(returnNum(arr));
        System.out.println("------------------");
        int[] nineArr = returnNineArr(88);
        System.out.println(Arrays.toString(nineArr));
        System.out.println("------------------");
        System.out.println(returnMaxValue(arr));
    }


    /**
     *  .给定一个数组(如果元素个数小于1，则返回0)，数组中的每一个元素代表一个小朋友的名称，
     *  可能存在重复，但没关系，这些小朋友围成一个圆圈，为了区分小朋友，我们从下标0开始的小朋友从1开始编号，
     *  编号完成以后，从编号为1的小朋友开始报数，
     *  凡是报到3的小朋友退出圈，然后下个小朋友继续从1开始报数，
     *  循环往复，问最后留下来的那一个小朋友的姓名(数组元素值)是什么?请返回一个整数
     * @param arr
     * @return
     */
    public static int returnNum(int [] arr){
        ArrayList<Integer> list = new ArrayList<>();
        for (int i : arr) {
            list.add(i);
        }
        if (list.size() <= 0){
            return 0;
        }
        int index = 0;
        int x = 1;
        boolean flag = true;
        System.out.println(list);
        while (flag){
            if (list.size() > 1){
                if(x % 3 == 0){
                    list.remove(index);
                    System.out.println(list);
                    x = 1;
                }
            }
            x++;
            if (list.size() == 1){
                flag = false;
            }else {
                // TODO
                index = (index + 1) % list.size(); // 更新索引
            }
        }
        System.out.println(list);
        return list.get(0);
    }

    /**
     * 给定一个十讲制整数(如果n>100000，则取100000)，然后取其绝对值，计算出该绝对值所对应的9进制所表示的数组
     * @param num
     * @return
     */
    public static int[] returnNineArr(int num){
        // 取绝对值
        int absN = Math.abs(num);
        // 如果n>100000，则取100000
        absN = Math.min(absN, 100000);
        // 转换为9进制
        ArrayList<Integer> nineBasedList = new ArrayList<>();
        while (absN > 0) {
            int remainder = absN % 9;
            nineBasedList.add(remainder);
            absN /= 9;
        }

        // 如果结果为空，则表示n为0
        if (nineBasedList.isEmpty()) {
            nineBasedList.add(0);
        }

        // 反转集合以获得正确的顺序
        Collections.reverse(nineBasedList);

        // 将ArrayList转换为数组
        int[] result = new int[nineBasedList.size()];
        for (int i = 0; i < nineBasedList.size(); i++) {
            result[i] = nineBasedList.get(i);
        }

        return result;
    }

    /**
     *  给定一个无序数组(如果元素个数小于2，则返回0)，
     *  否则将数组从小到大排序后，取其前 8 个数作为新数组(如果不足8个，就选取所有元素)，
     *  找出这个新数组相邻元素之间最大的差值。
     * @param arr
     * @return
     */

    public static int returnMaxValue(int [] arr){
        if (arr.length < 2){
            return 0;
        }
        Arrays.sort(arr);

        int[] arr2 = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            arr2[i] = arr[i];
        }
        System.out.println(Arrays.toString(arr2));

        // 取其前 8 个数作为新数组(如果不足8个，就选取所有元素)
        if (arr.length > 8){
            arr2 = new int[8];
            for (int i = 0; i < 8; i++) {
                arr2[i] = arr[i];
            }
        }

        System.out.println(Arrays.toString(arr2));
        int max = 0;
        // int[] arr = {3, 6, 9, 1, 5, 7, 2, 8, 4};
        for (int i = 0; i < arr2.length - 1;i++){
            int right = arr2[i + 1] - arr2[i];
            if (max < right){
                max = right;
            }

        }

        return max;
    }

}

